package com.cluster.user.util;

import java.io.BufferedWriter;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Stream;

public class LocalDataAggregation810 {
    private static final long MAX_FILE_SIZE = 1L * 1024 * 1024 * 1024; // 1GB in bytes
    private static long currentFileSize = 0;

    public static void main(String[] args) {
        // Step 1: 设定文件路径
        String directoryPath = "D:\\data\\yaxin_group\\upload"; // 目标文件夹路径
        String outputDirectory = "D:\\data\\yaxin_group\\output"; // 合并后的输出文件夹路径
        List<String[]> splitData = new ArrayList<>();

        // Step 2: 获取输出目录，并确保输出目录存在
        Path outputDirPath = Paths.get(outputDirectory);
        try {
            if (!Files.exists(outputDirPath)) {
                Files.createDirectories(outputDirPath); // 创建输出目录
            }

            // Step 3: 获取所有日期子目录并遍历
            Files.list(Paths.get(directoryPath))
                    .filter(Files::isDirectory) // 只选择目录
                    .forEach(dateDir -> {
                        System.out.println("Processing directory: " + dateDir.getFileName());
                        try {
                            // 遍历每个日期目录中的文件
                            Files.walk(dateDir) // 遍历目录及其子目录
                                    .filter(Files::isRegularFile) // 只处理文件
                                    .filter(Files -> !Files.getFileName().toString().contains("antgroup_output_check"))
                                    .flatMap(file -> {
                                        try {
                                            System.out.println("处理文件: " + file.getFileName().toString());
                                            // Step 4: 读取文件并过滤特定行
                                            return Files.lines(file)
                                                    .filter(line -> !line.contains("MARKLINE|0000|0000")) // 过滤行
                                                    .map(line -> {
                                                        String[] fields = line.split("\\|"); // 按照分隔符切割字段
                                                        // 获取文件上级目录的日期（假设日期是上级目录名称）
                                                        String date = file.getParent().getFileName().toString(); // 获取上级目录名（日期）

                                                        // 筛选出需要的字段（假设我们需要字段 1, 3, 5）
                                                        List<String> selectedFields = new ArrayList<>();
                                                        selectedFields.add(fields[1]);  // Field3
                                                        selectedFields.add(date);  // 上级目录的日期
                                                        selectedFields.add("ant"); // 固定值 "620"

                                                        return selectedFields.toArray(new String[0]); // 返回字段数组
                                                    });
                                        } catch (IOException e) {
                                            e.printStackTrace();
                                            return Stream.empty(); // 出现错误时跳过
                                        }
                                    })
                                    .forEach(data -> {
                                        try {
                                            // 检查当前输出文件的大小
                                            Path outputFile = getNextOutputFile(outputDirPath);
                                            BufferedWriter writer = Files.newBufferedWriter(outputFile);

                                            // 写入数据
                                            writer.write(String.join(",", data));
                                            writer.newLine();
                                            currentFileSize += data.length;  // 累加当前文件的大小

                                            writer.close();
                                        } catch (IOException e) {
                                            e.printStackTrace();
                                        }
                                    });
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    });

        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 获取下一个输出文件，如果当前文件达到 1GB 则切换到新的文件
     * @param outputDirPath 输出目录路径
     * @return 新的输出文件
     * @throws IOException
     */
    private static Path getNextOutputFile(Path outputDirPath) throws IOException {
        // 生成一个新的文件名
        String newFileName = "ant_merged_output_" + System.currentTimeMillis() + ".csv";
        Path outputFilePath = outputDirPath.resolve(newFileName);

        // 如果当前文件大小超过 1GB，则切换到新的文件
        if (Files.exists(outputFilePath) && Files.size(outputFilePath) > MAX_FILE_SIZE) {
            newFileName = "ant_merged_output_" + System.currentTimeMillis() + ".csv"; // 生成新的文件名
            outputFilePath = outputDirPath.resolve(newFileName);
        }

        // 如果文件不存在，则创建新文件
        if (!Files.exists(outputFilePath)) {
            Files.createFile(outputFilePath);
        }

        return outputFilePath;
    }
}
